Python Circuit Breaker: Veerkrachtige Applicaties Bouwen

In de wereld van gedistribueerde systemen en microservices zijn storingen onvermijdelijk. Services kunnen onbeschikbaar raken door netwerkproblemen, overbelaste servers of onverwachte bugs. Wanneer een falende service niet correct wordt afgehandeld, kan dit leiden tot cascade-fouten, waardoor hele systemen uitvallen. Het Circuit Breaker-patroon is een krachtige techniek om deze cascade-fouten te voorkomen en meer veerkrachtige applicaties te bouwen. Dit artikel biedt een uitgebreide handleiding voor de implementatie van het Circuit Breaker-patroon in Python.

Wat is het Circuit Breaker-patroon?

Het Circuit Breaker-patroon, geïnspireerd op elektrische stroomonderbrekers, fungeert als een proxy voor operaties die kunnen mislukken. Het bewaakt de succes- en faalpercentages van deze operaties en, wanneer een bepaalde faaldrempel is bereikt, "onderbreekt" het de schakelaar, waardoor verdere oproepen naar de falende service worden voorkomen. Dit geeft de falende service de tijd om te herstellen zonder te worden overweldigd door verzoeken, en voorkomt dat de aanroepende service middelen verspilt aan het proberen verbinding te maken met een service waarvan bekend is dat deze down is.

De Circuit Breaker heeft drie hoofdtoestanden:

• Closed (Gesloten): De circuit breaker is in de normale staat, waardoor oproepen naar de beschermde service kunnen worden doorgestuurd. Het bewaakt het succes en falen van deze oproepen.
• Open (Open): De circuit breaker is geactiveerd en alle oproepen naar de beschermde service worden geblokkeerd. Na een gespecificeerde time-out periode gaat de circuit breaker over naar de Half-Open-staat.
• Half-Open (Half-Open): De circuit breaker staat een beperkt aantal testoproepen toe naar de beschermde service. Als deze oproepen slagen, keert de circuit breaker terug naar de Closed-staat. Als ze falen, keert deze terug naar de Open-staat.

Hier is een eenvoudige analogie: stel je voor dat je geld probeert op te nemen bij een geldautomaat. Als de geldautomaat herhaaldelijk geen geld kan uitgeven (mogelijk vanwege een systeemfout bij de bank), zou een Circuit Breaker ingrijpen. In plaats van door te gaan met pogingen tot opnames die waarschijnlijk zullen mislukken, zou de Circuit Breaker tijdelijk verdere pogingen blokkeren (Open-staat). Na een tijdje zou het een enkele opnamepoging kunnen toestaan (Half-Open-staat). Als die poging slaagt, zou de Circuit Breaker de normale werking hervatten (Closed-staat). Als deze mislukt, zou de Circuit Breaker langer in de Open-staat blijven.

Waarom een Circuit Breaker gebruiken?

Het implementeren van een Circuit Breaker biedt verschillende voordelen:

• Voorkomt Cascade-fouten: Door oproepen naar een falende service te blokkeren, voorkomt de Circuit Breaker dat de fout zich verspreidt naar andere delen van het systeem.
• Verbetert Systeemveerkracht: De Circuit Breaker geeft falende services de tijd om te herstellen zonder te worden overweldigd door verzoeken, wat leidt tot een stabieler en veerkrachtiger systeem.
• Vermindert Middelenverbruik: Door onnodige oproepen naar een falende service te vermijden, vermindert de Circuit Breaker het verbruik van middelen, zowel bij de aanroepende als de aangeroepen service.
• Biedt Fallback-mechanismen: Wanneer het circuit open is, kan de aanroepende service een fallback-mechanisme uitvoeren, zoals het retourneren van een gecachte waarde of het weergeven van een foutmelding, wat zorgt voor een betere gebruikerservaring.

Een Circuit Breaker implementeren in Python

Er zijn verschillende manieren om het Circuit Breaker-patroon in Python te implementeren. U kunt uw eigen implementatie van de grond af opbouwen, of u kunt een bibliotheek van derden gebruiken. Hier zullen we beide benaderingen verkennen.

1. Een Aangepaste Circuit Breaker Bouwen

Laten we beginnen met een eenvoudige, aangepaste implementatie om de kernconcepten te begrijpen. Dit voorbeeld maakt gebruik van de `threading`-module voor thread-veiligheid en de `time`-module voor het afhandelen van time-outs.

            
import time
import threading

class CircuitBreaker:
    def __init__(self, failure_threshold, recovery_timeout):
        self.failure_threshold = failure_threshold
        self.recovery_timeout = recovery_timeout
        self.state = "CLOSED"
        self.failure_count = 0
        self.last_failure_time = None
        self.lock = threading.Lock()

    def call(self, func, *args, **kwargs):
        with self.lock:
            if self.state == "OPEN":
                if time.time() - self.last_failure_time > self.recovery_timeout:
                    self.state = "HALF_OPEN"
                else:
                    raise CircuitBreakerError("Circuit breaker is open")

        try:
            result = func(*args, **kwargs)
            self.reset()
            return result
        except Exception as e:
            self.record_failure()
            raise e

    def record_failure(self):
        with self.lock:
            self.failure_count += 1
            self.last_failure_time = time.time()

            if self.failure_count >= self.failure_threshold:
                self.state = "OPEN"
                print("Circuit breaker opened")

    def reset(self):
        with self.lock:
            self.failure_count = 0
            self.state = "CLOSED"
            print("Circuit breaker closed")

class CircuitBreakerError(Exception):
    pass

# Voorbeeldgebruik
def unreliable_service():
    # Simuleer een service die soms faalt
    import random
    if random.random() < 0.5:
        raise Exception("Service failed")
    else:
        return "Service successful"

circuit_breaker = CircuitBreaker(failure_threshold=3, recovery_timeout=10)

for i in range(10):
    try:
        result = circuit_breaker.call(unreliable_service)
        print(f"Call {i+1}: {result}")
    except CircuitBreakerError as e:
        print(f"Call {i+1}: {e}")
    except Exception as e:
        print(f"Call {i+1}: Service failed: {e}")
    time.sleep(1) 

            

              
                Copy
              
            
          

Uitleg:

• `CircuitBreaker` Klasse:
  • `__init__(self, failure_threshold, recovery_timeout)`: Initialiseert de circuit breaker met een faaldrempel (het aantal mislukkingen voordat het circuit wordt onderbroken), een herstel-time-out (de tijd om te wachten voordat een half-open staat wordt geprobeerd) en stelt de initiële staat in op `CLOSED`.
  • `call(self, func, *args, **kwargs)`: Dit is de hoofd-methode die de te beschermen functie omwikkelt. Het controleert de huidige staat van de circuit breaker. Als deze `OPEN` is, controleert het of de herstel-time-out is verstreken. Zo ja, dan gaat het naar `HALF_OPEN`. Anders wordt er een `CircuitBreakerError` gegenereerd. Als de staat niet `OPEN` is, voert het de functie uit en behandelt potentiële uitzonderingen.
  • `record_failure(self)`: Verhoogt het aantal mislukkingen en registreert de tijd van de mislukking. Als het aantal mislukkingen de drempel overschrijdt, wordt het circuit naar de `OPEN`-staat overgezet.
  • `reset(self)`: Reset het aantal mislukkingen en zet het circuit over naar de `CLOSED`-staat.
• `CircuitBreakerError` Klasse: Een aangepaste uitzondering die wordt gegenereerd wanneer de circuit breaker open is.
• `unreliable_service()` Functie: Simuleert een service die willekeurig faalt.
• Voorbeeldgebruik: Demonstreert hoe de `CircuitBreaker`-klasse kan worden gebruikt om de `unreliable_service()`-functie te beschermen.

Belangrijke overwegingen voor aangepaste implementatie:

• Thread-veiligheid: De `threading.Lock()` is cruciaal voor het waarborgen van thread-veiligheid, vooral in gelijktijdige omgevingen.
• Foutafhandeling: Het `try...except`-blok vangt uitzonderingen van de beschermde service en roept `record_failure()` aan.
• Staats-overgangen: De logica voor het overgaan tussen de `CLOSED`, `OPEN` en `HALF_OPEN`-staten is geïmplementeerd binnen de `call()` en `record_failure()`-methoden.

2. Een bibliotheek van derden gebruiken: `pybreaker`

Hoewel het bouwen van je eigen Circuit Breaker een goede leerervaring kan zijn, is het gebruik van een goed geteste bibliotheek van derden vaak een betere optie voor productieomgevingen. Een populaire Python-bibliotheek voor de implementatie van het Circuit Breaker-patroon is `pybreaker`.

Installatie:

            
    pip install pybreaker

            

              
                Copy
              
            
          

Voorbeeldgebruik:

            
import pybreaker
import time

# Definieer een aangepaste uitzondering voor onze service
class ServiceError(Exception):
    pass

# Simuleer een onbetrouwbare service
def unreliable_service():
    import random
    if random.random() < 0.5:
        raise ServiceError("Service failed")
    else:
        return "Service successful"

# Maak een CircuitBreaker-instantie aan
circuit_breaker = pybreaker.CircuitBreaker(
    fail_max=3,  # Aantal mislukkingen voordat het circuit wordt geopend
    reset_timeout=10,  # Tijd in seconden voordat een poging tot sluiten van het circuit
    name="MyService"
)

# Wikkel de onbetrouwbare service met de CircuitBreaker
@circuit_breaker
def call_unreliable_service():
    return unreliable_service()

# Roep de service aan
for i in range(10):
    try:
        result = call_unreliable_service()
        print(f"Call {i+1}: {result}")
    except pybreaker.CircuitBreakerError as e:
        print(f"Call {i+1}: Circuit breaker is open: {e}")
    except ServiceError as e:
        print(f"Call {i+1}: Service failed: {e}")
    time.sleep(1)

            

              
                Copy
              
            
          

Uitleg:

• Installatie: De `pip install pybreaker`-opdracht installeert de bibliotheek.
• `pybreaker.CircuitBreaker` Klasse:
  • `fail_max`: Specificeert het aantal opeenvolgende mislukkingen voordat de circuit breaker wordt geopend.
  • `reset_timeout`: Specificeert de tijd (in seconden) dat de circuit breaker open blijft voordat deze overgaat naar de half-open staat.
  • `name`: Een beschrijvende naam voor de circuit breaker.
• Decorator: De `@circuit_breaker`-decorator omwikkelt de `unreliable_service()`-functie, waardoor de circuit breaker-logica automatisch wordt afgehandeld.
• Foutafhandeling: Het `try...except`-blok vangt `pybreaker.CircuitBreakerError` op wanneer het circuit open is en `ServiceError` (onze aangepaste uitzondering) wanneer de service faalt.

Voordelen van het gebruik van `pybreaker`:

• Vereenvoudigde Implementatie: `pybreaker` biedt een schone en gebruiksvriendelijke API, waardoor boilerplate-code wordt verminderd.
• Thread-veiligheid: `pybreaker` is thread-veilig, waardoor het geschikt is voor gelijktijdige applicaties.
• Aanpasbaar: U kunt verschillende parameters configureren, zoals de faaldrempel, de reset-time-out en gebeurtenis-listeners.
• Gebeurtenis-listeners: `pybreaker` ondersteunt gebeurtenis-listeners, waardoor u de staat van de circuit breaker kunt volgen en acties kunt ondernemen (bijv. loggen, waarschuwingen verzenden).

3. Geavanceerde Circuit Breaker Concepten

Naast de basisimplementatie zijn er verschillende geavanceerde concepten om te overwegen bij het gebruik van Circuit Breakers:

• Metrics en Monitoring: Het verzamelen van metrics over de prestaties van uw Circuit Breakers is essentieel om hun gedrag te begrijpen en potentiële problemen te identificeren. Bibliotheken zoals Prometheus en Grafana kunnen worden gebruikt om deze metrics te visualiseren. Houd metrics bij zoals:
• Circuit Breaker Staat (Open, Closed, Half-Open)
• Aantal Succesvolle Oproepen
• Aantal Mislukte Oproepen
• Latentie van Oproepen
• Fallback-mechanismen: Wanneer het circuit open is, heeft u een strategie nodig om verzoeken af te handelen. Veelvoorkomende fallback-mechanismen zijn:
• Het retourneren van een gecachte waarde.
• Het weergeven van een foutmelding aan de gebruiker.
• Het aanroepen van een alternatieve service.
• Het retourneren van een standaardwaarde.
• Asynchrone Circuit Breakers: In asynchrone applicaties (met `asyncio`) moet u een asynchrone Circuit Breaker-implementatie gebruiken. Sommige bibliotheken bieden asynchrone ondersteuning.
• Bulkheads: Het Bulkhead-patroon isoleert delen van een applicatie om te voorkomen dat storingen in het ene deel zich verspreiden naar andere. Circuit Breakers kunnen in combinatie met Bulkheads worden gebruikt om nog grotere fouttolerantie te bieden.
• Tijdgebaseerde Circuit Breakers: In plaats van het aantal mislukkingen bij te houden, opent een tijdgebaseerde Circuit Breaker het circuit als de gemiddelde reactietijd van de beschermde service een bepaalde drempel overschrijdt binnen een bepaald tijdsvenster.

Praktische Voorbeelden en Gebruiksscenario's

Hier zijn enkele praktische voorbeelden van hoe u Circuit Breakers in verschillende scenario's kunt gebruiken:

• Microservices Architectuur: In een microservices architectuur zijn services vaak van elkaar afhankelijk. Een Circuit Breaker kan een service beschermen tegen te veel verzoeken wanneer een downstream service faalt. Bijvoorbeeld, een e-commerce applicatie kan aparte microservices hebben voor productcatalogus, orderverwerking en betalingsverwerking. Als de betalingsverwerkingsservice onbeschikbaar wordt, kan een Circuit Breaker in de orderverwerkingsservice voorkomen dat nieuwe orders worden aangemaakt, waardoor een cascade-fout wordt voorkomen.
• Databaseverbindingen: Als uw applicatie vaak verbinding maakt met een database, kan een Circuit Breaker verbindingsstorms voorkomen wanneer de database onbeschikbaar is. Denk aan een applicatie die verbinding maakt met een geografisch gedistribueerde database. Als een netwerkstoring een van de database-regio's treft, kan een Circuit Breaker voorkomen dat de applicatie herhaaldelijk probeert verbinding te maken met de onbeschikbare regio, wat de prestaties en stabiliteit verbetert.
• Externe API's: Bij het aanroepen van externe API's kan een Circuit Breaker uw applicatie beschermen tegen tijdelijke fouten en storingen. Veel organisaties vertrouwen op API's van derden voor verschillende functionaliteiten. Door API-aanroepen te omwikkelen met een Circuit Breaker, kunnen organisaties robuustere integraties bouwen en de impact van externe API-storingen verminderen.
• Retry Logic: Circuit Breakers kunnen samenwerken met retry-logica. Het is echter belangrijk om agressieve retries te vermijden die het probleem kunnen verergeren. De Circuit Breaker moet retries voorkomen wanneer de service bekend staat als onbeschikbaar.

Globale Overwegingen

Bij het implementeren van Circuit Breakers in een globale context is het belangrijk om rekening te houden met het volgende:

• Netwerklatentie: Netwerklatentie kan aanzienlijk variëren, afhankelijk van de geografische locatie van de aanroepende en aangeroepen services. Pas de herstel-time-out dienovereenkomstig aan. Bijvoorbeeld, oproepen tussen services in Noord-Amerika en Europa kunnen hogere latentie ervaren dan oproepen binnen dezelfde regio.
• Tijdzones: Zorg ervoor dat alle tijdstempels consistent worden afgehandeld in verschillende tijdzones. Gebruik UTC voor het opslaan van tijdstempels.
• Regionale Storingen: Houd rekening met de mogelijkheid van regionale storingen en implementeer Circuit Breakers om storingen tot specifieke regio's te isoleren.
• Culturele Overwegingen: Bij het ontwerpen van fallback-mechanismen, houd rekening met de culturele context van uw gebruikers. Foutmeldingen moeten bijvoorbeeld worden gelokaliseerd en cultureel passend zijn.

Best Practices

Hier zijn enkele best practices voor het effectief gebruiken van Circuit Breakers:

• Begin met Conservatieve Instellingen: Begin met een relatief lage faaldrempel en een langere herstel-time-out. Monitor het gedrag van de Circuit Breaker en pas de instellingen indien nodig aan.
• Gebruik Geschikte Fallback-mechanismen: Kies fallback-mechanismen die een goede gebruikerservaring bieden en de impact van storingen minimaliseren.
• Monitor de Staat van de Circuit Breaker: Houd de staat van uw Circuit Breakers bij en stel waarschuwingen in om u te informeren wanneer een circuit open is.
• Test het Gedrag van de Circuit Breaker: Simuleer storingen in uw testomgeving om ervoor te zorgen dat uw Circuit Breakers correct werken.
• Vermijd Overmatig Vertrouwen op Circuit Breakers: Circuit Breakers zijn een hulpmiddel voor het beperken van storingen, maar ze zijn geen vervanging voor het aanpakken van de onderliggende oorzaken van die storingen. Onderzoek en los de grondoorzaken van service-instabiliteit op.
• Overweeg Gedistribueerde Tracing: Integreer gedistribueerde tracing-tools (zoals Jaeger of Zipkin) om verzoeken over meerdere services te volgen. Dit kan u helpen de oorzaak van storingen te achterhalen en de impact van Circuit Breakers op het algehele systeem te begrijpen.

Conclusie

Het Circuit Breaker-patroon is een waardevol hulpmiddel voor het bouwen van fouttolerante en veerkrachtige applicaties. Door cascade-fouten te voorkomen en falende services de tijd te geven om te herstellen, kunnen Circuit Breakers de systeembetrouwbaarheid en beschikbaarheid aanzienlijk verbeteren. Of u nu kiest voor het bouwen van uw eigen implementatie of een bibliotheek van derden zoals `pybreaker` gebruikt, het begrijpen van de kernconcepten en best practices van het Circuit Breaker-patroon is essentieel voor het ontwikkelen van robuuste en betrouwbare software in de complexe gedistribueerde omgevingen van vandaag.

Door de principes uit deze gids toe te passen, kunt u Python-applicaties bouwen die veerkrachtiger zijn tegen storingen, wat zorgt voor een betere gebruikerservaring en een stabieler systeem, ongeacht uw globale bereik.